package com.atguigu.gmall.product.service.impl;

import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.product.mapper.SkuAttrValueMapper;
import com.atguigu.gmall.product.mapper.SkuSaleAttrValueMapper;
import com.atguigu.gmall.product.model.*;
import com.atguigu.gmall.product.service.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.assertj.core.error.ShouldBeSymbolicLink;
import org.junit.jupiter.api.Test;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class SkuManageServiceImpl implements SkuManageService {

    @Autowired
    private SkuInfoService skuInfoService;
    @Autowired
    private SkuImageService skuImageService;
    @Autowired
    private SkuAttrValueService skuAttrValueService;
    @Autowired
    private SkuSaleAttrValueService skuSaleAttrValueService;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private BaseTrademarkService baseTrademarkService;

    /**
     * 保存spu
     *
     * @param skuInfo
     * @return
     */
    @Override
    public void saveSkuInfo(SkuInfo skuInfo) {
        skuInfoService.save(skuInfo);
        Long skuId = skuInfo.getId();
        Long spuId = skuInfo.getSpuId();
        //储存SKUimage
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        if (!CollectionUtils.isEmpty(skuImageList)) {
            skuImageList.stream().forEach(skuImage -> {
                skuImage.setSkuId(skuId);
            });
            skuImageService.saveBatch(skuImageList);
        }
        //储存平台属性表
        List<SkuAttrValue> skuAttrValueList = skuInfo.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            skuAttrValueList.stream().forEach(skuAttrValue -> {
                skuAttrValue.setSkuId(skuId);
            });
            skuAttrValueService.saveBatch(skuAttrValueList);
        }
        //储存SKU销售属性值
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        if (!CollectionUtils.isEmpty(skuSaleAttrValueList)) {
            skuSaleAttrValueList.stream().forEach(skuSaleAttrValue -> {
                skuSaleAttrValue.setSkuId(skuId);
                skuSaleAttrValue.setSpuId(spuId);
            });
            skuSaleAttrValueService.saveBatch(skuSaleAttrValueList);
        }

        /**********************
         * 添加布隆
         */
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
        bloomFilter.add(skuId);
    }

    /**
     * 查询sku的分页信息
     *
     * @param skuInfoPage
     * @param category3Id
     * @return
     */
    @Override
    public Page<SkuInfo> getPageSkuinfoList(Page<SkuInfo> skuInfoPage, Long category3Id) {
        LambdaQueryWrapper<SkuInfo> qu = new LambdaQueryWrapper<>();
        qu.eq(SkuInfo::getCategory3Id, category3Id);
        return skuInfoService.page(skuInfoPage, qu);
    }

    /**
     * 上架
     *
     * @param skuId
     * @return
     */
    @Override
    public void onSale(Long skuId) {
        LambdaUpdateWrapper<SkuInfo> skuInfoLambdaUpdateChainWrapper = new LambdaUpdateWrapper<SkuInfo>();
        skuInfoLambdaUpdateChainWrapper.eq(SkuInfo::getId, skuId);
        skuInfoLambdaUpdateChainWrapper.set(SkuInfo::getIsSale, 1);
        skuInfoService.update(skuInfoLambdaUpdateChainWrapper);
    }

    /**
     * 下架
     *
     * @param skuId
     * @return
     */
    @Override
    public void cancelSale(Long skuId) {
        LambdaUpdateWrapper<SkuInfo> skuInfoLambdaUpdateChainWrapper = new LambdaUpdateWrapper<SkuInfo>();
        skuInfoLambdaUpdateChainWrapper.eq(SkuInfo::getId, skuId);
        skuInfoLambdaUpdateChainWrapper.set(SkuInfo::getIsSale, 0);
        skuInfoService.update(skuInfoLambdaUpdateChainWrapper);
    }

    /**
     * 根据skuId 获取最新的商品价格
     *
     * @param skuId
     * @return
     */
    @Override
    public BigDecimal getSkuPrice(Long skuId) {
        LambdaQueryWrapper<SkuInfo> skuInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        skuInfoLambdaQueryWrapper.eq(SkuInfo::getId, skuId);
        skuInfoLambdaQueryWrapper.select(SkuInfo::getPrice);
        SkuInfo skuinfo = skuInfoService.getOne(skuInfoLambdaQueryWrapper);
        if (skuinfo != null) {
            return skuinfo.getPrice();
        }
        return null;
    }

    /**
     * 根据skuId 获取平台属性数据
     *
     * @param skuId
     * @return
     */
    @Override
    public List<BaseAttrInfo> getAttrList(Long skuId) {
        //根据skuid查找平台属性表
//        LambdaQueryWrapper<SkuAttrValue> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(SkuAttrValue::getSkuId,skuId);
//        List<SkuAttrValue> list = skuAttrValueService.list(queryWrapper);
        SkuAttrValueMapper skuAttrValueMapper = (SkuAttrValueMapper) skuAttrValueService.getBaseMapper();
        List<BaseAttrInfo> attrList = skuAttrValueMapper.getAttrList(skuId);
        if (!CollectionUtils.isEmpty(attrList)) {
            attrList.stream().forEach((BaseAttrInfo) -> {
                BaseAttrInfo.setAttrValue(BaseAttrInfo.getAttrValueList().get(0).getValueName());
            });
        }
        return attrList;
    }
    /**
     * 根据spuId 获取到销售属性值Id 与skuId 组成的数据集
     * @param spuId
     * @return
     */
    @Override
    public Map<String, String> getSkuValueIdsMap(Long spuId) {
        HashMap<String, String> stringStringHashMap = new HashMap<>();
        SkuSaleAttrValueMapper skuSaleAttrValueMapper= (SkuSaleAttrValueMapper) skuSaleAttrValueService.getBaseMapper();
        List<Map<String,Object>> list =skuSaleAttrValueMapper.getSkuValueIdsMap(spuId);
        if (!CollectionUtils.isEmpty(list)) {
            list.stream().forEach(map->{
                String skuId = map.get("sku_id")+"";
                String valueIds = map.get("value_ids")+"";
                stringStringHashMap.put(valueIds,skuId);
            });
        }

        return stringStringHashMap;
    }
    /**
     * 根据品牌Id 获取品牌数据
     * @param tmId
     * @return
     */
    @Override
    public BaseTrademark getTrademark(Long tmId) {
        return    baseTrademarkService.getById(tmId);
    }
}
